#ifndef _THREAD_HPP__
#define _THREAD_HPP__


#include<iostream>
#include<string>
#include<functional>
#include<sys/types.h>
#include<unistd.h>




namespace ThreadModule
{
	using func_t = std::function<void(std::string)>;
	static int number = 1;

	enum class TSTATUS
	{
		NEW,
		RUNNING,
		STOP
	};


	class Thread
	{
	private:
		// 不加static是成员函数，有this指针，pthread不允许有两个参数
		static void *Routine(void* args)  // void* Routine(void* this,void* args)
		{
			Thread* t = static_cast<Thread*>(args);
			t->_status = TSTATUS::RUNNING;
			t->_func(t->Name()); //用来执行 _func 所代表的可调用对象

			return nullptr;
		}

		// 标记线程为分离状态
		void EnableDetach() 
		{
			_joinable = false;
		}

	public:
		Thread(func_t func):_func(func),_status(TSTATUS::NEW),_joinable(true)
		{
			_name = "Thread-" + std::to_string(number++);
			_pid = getpid();
		}

		// 启动线程
		bool Start()
		{
			if(_status != TSTATUS::RUNNING)
			{
				//pthread_create() 1.线程ID 2.线程属性(默认nullptr) 3.线程要执行的函数 4.给线程函数传数据
				int n = ::pthread_create(&_tid,nullptr,Routine,this);
				if(n != 0) return false;				
				return true;
			}
			return false;
		}

		// 停止线程
		bool Stop()
		{
			if(_status == TSTATUS::RUNNING)
			{
				int n = ::pthread_cancel(_tid);
				if(n != 0) return false;
				_status = TSTATUS::STOP;
				return true;
			}
			return false;
		}

		// 等待线程结束并回收资源
		bool Join()
		{
			if(_joinable)
			{
				int n = ::pthread_join(_tid,nullptr);
				if(n != 0) return false;
				_status = TSTATUS::STOP;
				return true;
			}
			return false;
		}

		// 分离线程
		void Detach()
		{
			EnableDetach();
			pthread_detach(_tid);
		}
		
		// 判断线程是否可连接
		bool IsJoinable()
		{
			return _joinable;
		}
		std::string Name() {return _name;}
		~Thread()
		{}
	private:
		std::string _name;
		pthread_t _tid;    // 线程ID
		pid_t _pid;        // 进程ID
		bool _joinable;    // 是否是分离的，默认不是
		func_t _func;      // 执行什么方法
		TSTATUS _status;   // 线程的状态
	};
};














#endif